/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.mengmeizi.util;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.net.http.AndroidHttpClient;
import android.os.AsyncTask;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.AbsListView.LayoutParams;
import android.widget.ImageView;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.concurrent.ConcurrentHashMap;

/**
 * This helper class download images from the Internet and binds those with the
 * provided ImageView.
 * <p>
 * It requires the INTERNET permission, which should be added to your
 * application's manifest file.
 * </p>
 * A local cache of downloaded images is maintained internally to improve
 * performance.
 */
public class ImageManager {
    // private static final String LOG_TAG = "ImageDownloader";

    private static ImageManager instance;

    private static HashMap<String, Handler> handlerMap;

    // private Context context;

    public static ImageManager getManger() {
        if (instance == null) {
            if (handlerMap == null) {
                handlerMap = new HashMap<String, Handler>();
            }
            instance = new ImageManager();
        }
        return instance;
    }

    /**
     * Download the specified image from the Internet and binds it to the
     * provided ImageView. The binding is immediate if the image is found in the
     * cache and will be done asynchronously otherwise. A null bitmap will be
     * associated to the ImageView if an error occurs.
     * 
     * @param url The URL of the image to download.
     * @param imageView The ImageView to bind the downloaded image to.
     */
    public void loadImage2ImageView(Context context, String url, ImageView imageView, int type, Handler handler) {
        // this.context = context;
        resetPurgeTimer();
        String cacheFileName = null;
        String cacheFile = null;

        if (handler != null) {
            handlerMap.put(url, handler);
        }

        if (url.contains("http://")) {
            cacheFile = Const.FILENAME_IMGCACHE + ".nomedia";
            cacheFileName = Const.FILENAME_IMGCACHE + new String(Base64.encode(url.getBytes(), Base64.NO_WRAP));
        } else {
            cacheFileName = url;
        }

        if (url.endsWith("_big")) { // 从管理进入详细
            loadImageFromLocal(url, cacheFileName.substring(0, url.indexOf("_big")), imageView, type);
        } else {
            Bitmap bitmap = getBitmapFromCache(url);

            if (bitmap == null) {
                File file = new File(cacheFileName);
                if (!file.exists()) {
                    file = new File(cacheFile);
                    if (!file.exists()) {
                        file.mkdirs();
                    }
                    forceDownload(url, cacheFileName, imageView, type);
                } else {
                    loadImageFromLocal(url, cacheFileName, imageView, type);
                }
            } else if (!bitmap.isRecycled()) {
                cancelPotentialDownload(url, imageView);
                if (type == Const.TYPE_BIG_IMAGE) {
                    Message msg = new Message();
                    msg.what = Const.REFRESH_IMG;
                    msg.obj = bitmap;
                    if (handlerMap.get(url) != null) {
                        handlerMap.get(url).sendMessage(msg);
                    }
                }
                imageView.setImageBitmap(bitmap);
            }
        }
    }

    private void loadImageFromLocal(String url, String cacheFileName, ImageView imageView, int type) {
        Bitmap bitmap = null;
        if (type == Const.TYPE_MANAGER_IMAGE) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            bitmap = BitmapFactory.decodeFile(cacheFileName, options);
            options.inJustDecodeBounds = false;
            options.inSampleSize = 4; // 缩小为原来图片4*4=16分之一
            bitmap = BitmapFactory.decodeFile(cacheFileName, options);
        } else {
            bitmap = BitmapFactory.decodeFile(cacheFileName);
        }
        if (bitmap != null) {
            if (type == Const.TYPE_SMALL_IMAGE) {
                int width = bitmap.getWidth();
                int height = bitmap.getHeight();
                LayoutParams layoutParams = new LayoutParams(Tools.getItemWidth(), (height * Tools.getItemWidth())
                        / width);
                imageView.setLayoutParams(layoutParams);
                imageView.setVisibility(View.VISIBLE);
            } else if (type == Const.TYPE_BIG_IMAGE) {
                Handler handler = handlerMap.get(url);
                if (handler != null) {
                    Message msg = new Message();
                    msg.what = Const.REFRESH_IMG;
                    msg.obj = bitmap;
                    handler.sendMessage(msg);
                }
            } else if (type == Const.TYPE_MANAGER_IMAGE) {
                android.widget.RelativeLayout.LayoutParams layoutParams = new android.widget.RelativeLayout.LayoutParams(
                        Tools.getItemWidth(), 160);
                imageView.setLayoutParams(layoutParams);
                imageView.setVisibility(View.VISIBLE);
            }
        }
        addBitmapToCache(url, bitmap);
        imageView.setImageBitmap(bitmap);
    }

    public void removeBitmap(Bitmap bitmap, String url) {
        // 删除缓存
        sHardBitmapCache.remove(url);
        sSoftBitmapCache.remove(url);
        // 释放bitmap
        bitmap.recycle();
    }

    /*
     * Same as download but the image is always downloaded and the cache is not
     * used. Kept private at the moment as its interest is not clear. private
     * void forceDownload(String url, ImageView view) { forceDownload(url, view,
     * null); }
     */

    /**
     * Same as download but the image is always downloaded and the cache is not
     * used. Kept private at the moment as its interest is not clear.
     */
    private void forceDownload(String url, String cacheFileName, ImageView imageView, int type) {
        // State sanity: url is guaranteed to never be null in
        // DownloadedDrawable and cache keys.
        if (url == null) {
            imageView.setImageDrawable(null);
            return;
        }

        if (cancelPotentialDownload(url, imageView)) {
            BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
            DownloadedDrawable downloadedDrawable = new DownloadedDrawable(task);
            imageView.setImageDrawable(downloadedDrawable);
            imageView.setMinimumHeight(156);
            task.execute(url, cacheFileName, String.valueOf(type));
        }
    }

    /**
     * Returns true if the current download has been canceled or if there was no
     * download in progress on this image view. Returns false if the download in
     * progress deals with the same url. The download is not stopped in that
     * case.
     */
    public static boolean cancelPotentialDownload(String url, ImageView imageView) {
        BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);

        if (bitmapDownloaderTask != null) {
            String bitmapUrl = bitmapDownloaderTask.url;
            if ((bitmapUrl == null) || (!bitmapUrl.equals(url))) {
                bitmapDownloaderTask.cancel(true);
            } else {
                // The same URL is already being downloaded.
                return false;
            }
        }
        return true;
    }

    /**
     * @param imageView Any imageView
     * @return Retrieve the currently active download task (if any) associated
     *         with this imageView. null if there is no such task.
     */
    private static BitmapDownloaderTask getBitmapDownloaderTask(ImageView imageView) {
        if (imageView != null) {
            Drawable drawable = imageView.getDrawable();
            if (drawable instanceof DownloadedDrawable) {
                DownloadedDrawable downloadedDrawable = (DownloadedDrawable) drawable;
                return downloadedDrawable.getBitmapDownloaderTask();
            }
        }
        return null;
    }

    Bitmap downloadBitmap(String url, String cacheFileName, final String type) {
        // final int IO_BUFFER_SIZE = 4 * 1024;

        // AndroidHttpClient is not allowed to be used from the main thread
        // final HttpClient client = new DefaultHttpClient();

        final HttpClient client = AndroidHttpClient.newInstance("Android");
        final HttpGet getRequest = new HttpGet(url);

        // final NetWorkTool netWorkTool = new NetWorkTool(context);
        // netWorkTool.setMethod(Method.GET);
        // netWorkTool.setURL(url);
        // netWorkTool.setTimeout(5000);
        try {
            // HttpURLConnection connection = netWorkTool.httpConnection();
            // int response = connection.getResponseCode();
            HttpResponse response = client.execute(getRequest);
            final int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                // Log.w("ImageDownloader", "Error " + statusCode +
                // " while retrieving bitmap from " + url);
                return null;
            }

            final HttpEntity entity = response.getEntity();
            if (entity != null) {
                // if (response == HttpURLConnection.HTTP_OK) {
                InputStream inputStream = null;
                try {
                    inputStream = entity.getContent();
                    long size = entity.getContentLength();
                    // Bug on slow connections, fixed in future release.
                    // Bitmap bitmap = BitmapFactory.decodeStream(new
                    // FlushedInputStream(inputStream, myTask));
                    Bitmap bitmap = BitmapFactory.decodeStream(new SizeInputStream(inputStream, size, url));

                    final Bitmap bitmapFile = Bitmap.createBitmap(bitmap);
                    final String cacheFile = cacheFileName;
                    new Thread() {

                        @Override
                        public void run() {
                            // TODO Auto-generated method stub
                            super.run();
                            // create a file to write bitmap data
                            if (Tools.hasSDCard()) {
                                ByteArrayOutputStream bos = null;
                                try {
                                    File f = new File(cacheFile);
                                    f.createNewFile();
                                    // Convert bitmap to byte array
                                    bos = new ByteArrayOutputStream();
                                    int rate;
                                    if (type.equals(String.valueOf(Const.TYPE_BIG_IMAGE))) {
                                        rate = 100;
                                    } else {
                                        rate = 80;
                                    }
                                    if (!bitmapFile.isRecycled()) {
                                        bitmapFile.compress(CompressFormat.JPEG, rate, bos);
                                        byte[] bitmapdata = bos.toByteArray();
                                        // write the bytes in file
                                        FileOutputStream fos = new FileOutputStream(f);
                                        fos.write(bitmapdata);
                                    }
                                } catch (IOException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                                } finally {
                                    try {
                                        if (bos != null) {
                                            bos.close();
                                        }
                                        // if (bitmap != null) {
                                        // bitmap.recycle();
                                        // }
                                    } catch (IOException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                }
                            }
                        }

                    }.start();

                    return bitmap;
                } finally {
                    if (inputStream != null) {
                        inputStream.close();
                    }
                    // if (bos != null) {
                    // bos.close();
                    // }
                    entity.consumeContent();
                }
            }
        } catch (IOException e) {
            getRequest.abort();
            // Log.w(LOG_TAG, "I/O error while retrieving bitmap from " + url,
            // e);
        } catch (IllegalStateException e) {
            getRequest.abort();
            // Log.w(LOG_TAG, "Incorrect URL: " + url);
        } catch (Exception e) {
            getRequest.abort();
            // Log.w(LOG_TAG, "Error while retrieving bitmap from " + url, e);
        } finally {
            if ((client instanceof AndroidHttpClient)) {
                ((AndroidHttpClient) client).close();
            }
        }
        return null;
    }

    /*
     * An InputStream that skips the exact number of bytes provided, unless it
     * reaches EOF.
     */
    static class FlushedInputStream extends FilterInputStream {
        BitmapDownloaderTask myTask;

        public FlushedInputStream(InputStream inputStream) {
            super(inputStream);
        }

        @Override
        public long skip(long n) throws IOException {
            long totalBytesSkipped = 0L;
            while (totalBytesSkipped < n) {
                long bytesSkipped = in.skip(n - totalBytesSkipped);
                if (bytesSkipped == 0L) {
                    int b = read();
                    if (b < 0) {
                        break; // we reached EOF
                    } else {
                        bytesSkipped = 1; // we read one byte
                    }
                }
                totalBytesSkipped += bytesSkipped;
            }
            return totalBytesSkipped;
        }
    }

    /**
     * The actual AsyncTask that will asynchronously download the image.
     */
    class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {

        private final WeakReference<ImageView> imageViewReference;

        private String url;

        private String type;

        public BitmapDownloaderTask(ImageView imageView) {
            imageViewReference = new WeakReference<ImageView>(imageView);
        }

        /**
         * Actual download method.
         */
        @Override
        protected Bitmap doInBackground(String... params) {
            url = params[0];
            type = params[2];

            return downloadBitmap(url, params[1], type);
        }

        /**
         * Once the image is downloaded, associates it to the imageView
         */
        @Override
        protected void onPostExecute(Bitmap bitmap) {
            if (isCancelled()) {
                bitmap = null;
            }

            addBitmapToCache(url, bitmap);

            if (imageViewReference != null) {
                ImageView imageView = imageViewReference.get();
                BitmapDownloaderTask bitmapDownloaderTask = getBitmapDownloaderTask(imageView);
                // Change bitmap only if this process is still associated with
                // it
                // Or if we don't use any bitmap to task association
                // (NO_DOWNLOADED_DRAWABLE mode)
                if ((this == bitmapDownloaderTask)) {
                    if (bitmap != null) {
                        if (type.equals(String.valueOf(Const.TYPE_SMALL_IMAGE))) {
                            int width = bitmap.getWidth();
                            int height = bitmap.getHeight();
                            LayoutParams layoutParams = new LayoutParams(Tools.getItemWidth(),
                                    (height * Tools.getItemWidth()) / width);
                            imageView.setLayoutParams(layoutParams);
                            imageView.setVisibility(View.VISIBLE);

                        } else if (type.equals(String.valueOf(Const.TYPE_BIG_IMAGE))) {
                            if (handlerMap != null && handlerMap.get(url) != null) {
                                Message msg = new Message();
                                msg.what = Const.REFRESH_IMG;
                                msg.obj = bitmap;
                                handlerMap.get(url).sendMessage(msg);
                            }
                        }
                    } else {
                        handlerMap.get(url).sendEmptyMessage(Const.CHECK_NETWORK);
                    }
                    imageView.setImageBitmap(bitmap);
                }
            }
        }
    }

    /**
     * A fake Drawable that will be attached to the imageView while the download
     * is in progress.
     * <p>
     * Contains a reference to the actual download task, so that a download task
     * can be stopped if a new binding is required, and makes sure that only the
     * last started download process can bind its result, independently of the
     * download finish order.
     * </p>
     */
    static class DownloadedDrawable extends ColorDrawable {
        private final WeakReference<BitmapDownloaderTask> bitmapDownloaderTaskReference;

        public DownloadedDrawable(BitmapDownloaderTask bitmapDownloaderTask) {
            super(Color.WHITE);
            bitmapDownloaderTaskReference = new WeakReference<BitmapDownloaderTask>(bitmapDownloaderTask);
        }

        public BitmapDownloaderTask getBitmapDownloaderTask() {
            return bitmapDownloaderTaskReference.get();
        }
    }

    /*
     * Cache-related fields and methods. We use a hard and a soft cache. A soft
     * reference cache is too aggressively cleared by the Garbage Collector.
     */

    private static final int HARD_CACHE_CAPACITY = 20;

    private static final int DELAY_BEFORE_PURGE = 10 * 1000; // in milliseconds

    // Hard cache, with a fixed maximum capacity and a life duration
    @SuppressWarnings("serial")
    private final HashMap<String, Bitmap> sHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY / 2,
            0.75f, true) {
        @Override
        protected boolean removeEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {
            if (size() > HARD_CACHE_CAPACITY) {
                // Entries push-out of hard reference cache are transferred to
                // soft reference cache
                sSoftBitmapCache.put(eldest.getKey(), new SoftReference<Bitmap>(eldest.getValue()));
                return true;
            } else
                return false;
        }
    };

    // Soft cache for bitmaps kicked out of hard cache
    private final static ConcurrentHashMap<String, SoftReference<Bitmap>> sSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>(
            HARD_CACHE_CAPACITY / 2);

    private final Handler purgeHandler = new Handler();

    private final Runnable purger = new Runnable() {
        public void run() {
            clearCache();
        }
    };

    /**
     * Adds this bitmap to the cache.
     * 
     * @param bitmap The newly downloaded bitmap.
     */
    public void addBitmapToCache(String url, Bitmap bitmap) {
        if (bitmap != null) {
            synchronized (sHardBitmapCache) {
                sHardBitmapCache.put(url, bitmap);
            }
        }
    }

    /**
     * @param url The URL of the image that will be retrieved from the cache.
     * @return The cached bitmap or null if it was not found.
     */
    public Bitmap getBitmapFromCache(String url) {
        // First try the hard reference cache
        synchronized (sHardBitmapCache) {
            final Bitmap bitmap = sHardBitmapCache.get(url);
            if (bitmap != null) {
                // Bitmap found in hard cache
                // Move element to first position, so that it is removed last
                sHardBitmapCache.remove(url);
                sHardBitmapCache.put(url, bitmap);
                return bitmap;
            }
        }

        // Then try the soft reference cache
        SoftReference<Bitmap> bitmapReference = sSoftBitmapCache.get(url);
        if (bitmapReference != null) {
            final Bitmap bitmap = bitmapReference.get();
            if (bitmap != null) {
                // Bitmap found in soft cache
                return bitmap;
            } else {
                // Soft reference has been Garbage Collected
                sSoftBitmapCache.remove(url);
            }
        }

        return null;
    }

    /**
     * Clears the image cache used internally to improve performance. Note that
     * for memory efficiency reasons, the cache will automatically be cleared
     * after a certain inactivity delay.
     */
    public void clearCache() {
        sHardBitmapCache.clear();
        sSoftBitmapCache.clear();
    }

    /**
     * Allow a new delay before the automatic cache clear is done.
     */
    private void resetPurgeTimer() {
        purgeHandler.removeCallbacks(purger);
        purgeHandler.postDelayed(purger, DELAY_BEFORE_PURGE);
    }

    class SizeInputStream extends InputStream {
        // The InputStream to read bytes from
        private InputStream in = null;

        // The number of bytes that can be read from the InputStream
        private int size = 0;

        // The number of bytes that have been read from the InputStream
        private int bytesRead = 0;

        String url;

        private Message msg;

        public SizeInputStream(InputStream in, long size, String url) {
            this.in = in;
            this.size = (int) size;
            this.url = url;
        }

        public int available() {
            return (size - bytesRead);
        }

        public int read() throws IOException {
            int b = in.read();
            if (b != -1) {
                bytesRead++;
            }
            // 刷新
            PublishLoading(bytesRead);
            return b;
        }

        public int read(byte[] b) throws IOException {
            int read = in.read(b);
            bytesRead += read;
            // 刷新
            PublishLoading(bytesRead);
            return read;
        }

        public int read(byte[] b, int off, int len) throws IOException {
            int read = in.read(b, off, len);
            bytesRead += read;
            // 刷新
            PublishLoading(bytesRead);
            return read;
        }

        private void PublishLoading(int read) {
            Handler handler = handlerMap.get(url);
            if (handler != null) {
                msg = new Message();
                msg.obj = read * 1.0f / size;
                msg.what = Const.LOADING_PUBLISH;
                handler.sendMessage(msg);
            }

        }
    }
}
